From afd99d3579bc8569b68b60302c631d6003629519 Mon Sep 17 00:00:00 2001 From: Paolo Borelli Date: Sat, 1 Sep 2012 18:49:02 +0200 Subject: [PATCH] Make spinbutton orientable https://bugzilla.gnome.org/show_bug.cgi?id=683168 --- gtk/gtkentry.c | 54 +++++++-- gtk/gtkentry.h | 8 +- gtk/gtkspinbutton.c | 263 ++++++++++++++++++++++++++++++++--------- tests/testspinbutton.c | 73 +++++++----- 4 files changed, 306 insertions(+), 92 deletions(-) diff --git a/gtk/gtkentry.c b/gtk/gtkentry.c index 8ebb977f39..ecbfd201e9 100644 --- a/gtk/gtkentry.c +++ b/gtk/gtkentry.c @@ -564,6 +564,11 @@ static void gtk_entry_get_text_area_size (GtkEntry *entry, gint *y, gint *width, gint *height); +static void gtk_entry_get_frame_size (GtkEntry *entry, + gint *x, + gint *y, + gint *width, + gint *height); static void get_text_area_size (GtkEntry *entry, gint *x, gint *y, @@ -705,6 +710,7 @@ gtk_entry_class_init (GtkEntryClass *class) class->toggle_overwrite = gtk_entry_toggle_overwrite; class->activate = gtk_entry_real_activate; class->get_text_area_size = gtk_entry_get_text_area_size; + class->get_frame_size = gtk_entry_get_frame_size; quark_inner_border = g_quark_from_static_string ("gtk-entry-inner-border"); quark_password_hint = g_quark_from_static_string ("gtk-entry-password-hint"); @@ -3395,12 +3401,11 @@ get_text_area_size (GtkEntry *entry, static void -get_frame_size (GtkEntry *entry, - gboolean relative_to_window, - gint *x, - gint *y, - gint *width, - gint *height) +gtk_entry_get_frame_size (GtkEntry *entry, + gint *x, + gint *y, + gint *width, + gint *height) { GtkEntryPrivate *priv = entry->priv; GtkAllocation allocation; @@ -3415,7 +3420,7 @@ get_frame_size (GtkEntry *entry, gtk_widget_get_allocation (widget, &allocation); if (x) - *x = relative_to_window ? allocation.x : 0; + *x = allocation.x; if (y) { @@ -3424,8 +3429,7 @@ get_frame_size (GtkEntry *entry, else *y = (allocation.height - req_height) / 2; - if (relative_to_window) - *y += allocation.y; + *y += allocation.y; } if (width) @@ -3440,6 +3444,36 @@ get_frame_size (GtkEntry *entry, } } +static void +get_frame_size (GtkEntry *entry, + gboolean relative_to_window, + gint *x, + gint *y, + gint *width, + gint *height) +{ + GtkEntryClass *class; + GtkWidget *widget = GTK_WIDGET (entry); + + g_return_if_fail (GTK_IS_ENTRY (entry)); + + class = GTK_ENTRY_GET_CLASS (entry); + + if (class->get_frame_size) + class->get_frame_size (entry, x, y, width, height); + + if (!relative_to_window) + { + GtkAllocation allocation; + gtk_widget_get_allocation (widget, &allocation); + + if (x) + *x -= allocation.x; + if (y) + *y -= allocation.y; + } +} + static void gtk_entry_size_allocate (GtkWidget *widget, GtkAllocation *allocation) @@ -5939,7 +5973,7 @@ get_layout_position (GtkEntry *entry, layout = gtk_entry_ensure_layout (entry, TRUE); - gtk_entry_get_text_area_size (entry, NULL, NULL, &area_width, &area_height); + get_text_area_size (entry, NULL, NULL, &area_width, &area_height); area_height = PANGO_SCALE * area_height; line = pango_layout_get_lines_readonly (layout)->data; diff --git a/gtk/gtkentry.h b/gtk/gtkentry.h index 338c8d279b..50ca934bd4 100644 --- a/gtk/gtkentry.h +++ b/gtk/gtkentry.h @@ -105,12 +105,17 @@ struct _GtkEntryClass void (* paste_clipboard) (GtkEntry *entry); void (* toggle_overwrite) (GtkEntry *entry); - /* hook to add other objects beside the entry (like in GtkSpinButton) */ + /* hooks to add other objects beside the entry (like in GtkSpinButton) */ void (* get_text_area_size) (GtkEntry *entry, gint *x, gint *y, gint *width, gint *height); + void (* get_frame_size) (GtkEntry *entry, + gint *x, + gint *y, + gint *width, + gint *height); /* Padding for future expansion */ void (*_gtk_reserved1) (void); @@ -120,7 +125,6 @@ struct _GtkEntryClass void (*_gtk_reserved5) (void); void (*_gtk_reserved6) (void); void (*_gtk_reserved7) (void); - void (*_gtk_reserved8) (void); }; GType gtk_entry_get_type (void) G_GNUC_CONST; diff --git a/gtk/gtkspinbutton.c b/gtk/gtkspinbutton.c index 8aaacaeef4..b5523dbfe4 100644 --- a/gtk/gtkspinbutton.c +++ b/gtk/gtkspinbutton.c @@ -42,6 +42,8 @@ #include "gtkicontheme.h" #include "gtkintl.h" #include "gtkmarshalers.h" +#include "gtkorientable.h" +#include "gtkorientableprivate.h" #include "gtkprivate.h" #include "gtksettings.h" #include "gtkstock.h" @@ -164,6 +166,8 @@ struct _GtkSpinButtonPrivate gdouble climb_rate; gdouble timer_step; + GtkOrientation orientation; + guint button : 2; guint digits : 10; guint need_timer : 1; @@ -182,7 +186,8 @@ enum { PROP_NUMERIC, PROP_WRAP, PROP_UPDATE_POLICY, - PROP_VALUE + PROP_VALUE, + PROP_ORIENTATION }; /* Signals */ @@ -214,7 +219,9 @@ static void gtk_spin_button_unrealize (GtkWidget *widget); static void gtk_spin_button_get_preferred_width (GtkWidget *widget, gint *minimum, gint *natural); - +static void gtk_spin_button_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural); static void gtk_spin_button_size_allocate (GtkWidget *widget, GtkAllocation *allocation); static gint gtk_spin_button_draw (GtkWidget *widget, @@ -249,6 +256,13 @@ static void gtk_spin_button_get_text_area_size (GtkEntry *entry, gint *y, gint *width, gint *height); +static void gtk_spin_button_get_frame_size (GtkEntry *entry, + gint *x, + gint *y, + gint *width, + gint *height); +static void gtk_spin_button_set_orientation (GtkSpinButton *spin_button, + GtkOrientation orientation); static void gtk_spin_button_snap (GtkSpinButton *spin_button, gdouble val); static void gtk_spin_button_insert_text (GtkEditable *editable, @@ -267,6 +281,7 @@ static gint gtk_spin_button_default_output (GtkSpinButton *spin_button); static guint spinbutton_signals[LAST_SIGNAL] = {0}; G_DEFINE_TYPE_WITH_CODE (GtkSpinButton, gtk_spin_button, GTK_TYPE_ENTRY, + G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL) G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE, gtk_spin_button_editable_init)) @@ -293,6 +308,7 @@ gtk_spin_button_class_init (GtkSpinButtonClass *class) widget_class->realize = gtk_spin_button_realize; widget_class->unrealize = gtk_spin_button_unrealize; widget_class->get_preferred_width = gtk_spin_button_get_preferred_width; + widget_class->get_preferred_height = gtk_spin_button_get_preferred_height; widget_class->size_allocate = gtk_spin_button_size_allocate; widget_class->draw = gtk_spin_button_draw; widget_class->scroll_event = gtk_spin_button_scroll; @@ -308,6 +324,7 @@ gtk_spin_button_class_init (GtkSpinButtonClass *class) entry_class->activate = gtk_spin_button_activate; entry_class->get_text_area_size = gtk_spin_button_get_text_area_size; + entry_class->get_frame_size = gtk_spin_button_get_frame_size; class->input = NULL; class->output = NULL; @@ -384,6 +401,10 @@ gtk_spin_button_class_init (GtkSpinButtonClass *class) 0.0, GTK_PARAM_READWRITE)); + g_object_class_override_property (gobject_class, + PROP_ORIENTATION, + "orientation"); + gtk_widget_class_install_style_property_parser (widget_class, g_param_spec_enum ("shadow-type", "Shadow Type", @@ -561,6 +582,9 @@ gtk_spin_button_set_property (GObject *object, case PROP_VALUE: gtk_spin_button_set_value (spin_button, g_value_get_double (value)); break; + case PROP_ORIENTATION: + gtk_spin_button_set_orientation (spin_button, g_value_get_enum (value)); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -602,6 +626,9 @@ gtk_spin_button_get_property (GObject *object, case PROP_VALUE: g_value_set_double (value, gtk_adjustment_get_value (priv->adjustment)); break; + case PROP_ORIENTATION: + g_value_set_enum (value, priv->orientation); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -636,6 +663,8 @@ gtk_spin_button_init (GtkSpinButton *spin_button) priv->wrap = FALSE; priv->snap_to_ticks = FALSE; + priv->orientation = GTK_ORIENTATION_HORIZONTAL; + gtk_spin_button_set_adjustment (spin_button, gtk_adjustment_new (0, 0, 0, 0, 0, 0)); @@ -696,6 +725,7 @@ gtk_spin_button_panel_nthchildize_context (GtkSpinButton *spin_button, GtkStyleContext *context, GdkWindow *panel) { + GtkSpinButtonPrivate *priv = spin_button->priv; GtkWidget *widget = GTK_WIDGET (spin_button); GtkWidgetPath *path, *siblings_path; GtkTextDirection direction; @@ -706,21 +736,31 @@ gtk_spin_button_panel_nthchildize_context (GtkSpinButton *spin_button, * for the button panels */ path = _gtk_widget_create_path (widget); - direction = gtk_widget_get_direction (widget); siblings_path = gtk_widget_path_new (); - /* flip children order for RTL */ - if (direction == GTK_TEXT_DIR_RTL) + if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) { - up_pos = gtk_widget_path_append_type (siblings_path, GTK_TYPE_SPIN_BUTTON); - down_pos = gtk_widget_path_append_type (siblings_path, GTK_TYPE_SPIN_BUTTON); - gtk_widget_path_append_type (siblings_path, GTK_TYPE_ENTRY); + direction = gtk_widget_get_direction (widget); + + /* flip children order for RTL */ + if (direction == GTK_TEXT_DIR_RTL) + { + up_pos = gtk_widget_path_append_type (siblings_path, GTK_TYPE_SPIN_BUTTON); + down_pos = gtk_widget_path_append_type (siblings_path, GTK_TYPE_SPIN_BUTTON); + gtk_widget_path_append_type (siblings_path, GTK_TYPE_ENTRY); + } + else + { + gtk_widget_path_append_type (siblings_path, GTK_TYPE_ENTRY); + down_pos = gtk_widget_path_append_type (siblings_path, GTK_TYPE_SPIN_BUTTON); + up_pos = gtk_widget_path_append_type (siblings_path, GTK_TYPE_SPIN_BUTTON); + } } else { - gtk_widget_path_append_type (siblings_path, GTK_TYPE_ENTRY); - down_pos = gtk_widget_path_append_type (siblings_path, GTK_TYPE_SPIN_BUTTON); up_pos = gtk_widget_path_append_type (siblings_path, GTK_TYPE_SPIN_BUTTON); + gtk_widget_path_append_type (siblings_path, GTK_TYPE_ENTRY); + down_pos = gtk_widget_path_append_type (siblings_path, GTK_TYPE_SPIN_BUTTON); } gtk_widget_path_iter_add_class (siblings_path, up_pos, GTK_STYLE_CLASS_BUTTON); @@ -730,7 +770,7 @@ gtk_spin_button_panel_nthchildize_context (GtkSpinButton *spin_button, gtk_widget_path_iter_add_class (siblings_path, up_pos, GTK_STYLE_CLASS_SPINBUTTON); gtk_widget_path_iter_add_class (siblings_path, down_pos, GTK_STYLE_CLASS_SPINBUTTON); - if (panel == spin_button->priv->down_panel) + if (panel == priv->down_panel) { gtk_widget_path_append_with_siblings (path, siblings_path, up_pos); gtk_widget_path_append_with_siblings (path, siblings_path, down_pos); @@ -813,17 +853,19 @@ gtk_spin_button_panel_get_context (GtkSpinButton *spin_button, return context; } -static gint -gtk_spin_button_panel_get_width (GtkSpinButton *spin_button, - GdkWindow *panel) +static void +gtk_spin_button_panel_get_size (GtkSpinButton *spin_button, + GdkWindow *panel, + gint *width, + gint *height) { GtkBorder button_padding, button_border; GtkStyleContext *context; GtkStateFlags state; - gint icon_size, width, height; + gint icon_size, w, h; - gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &width, &height); - icon_size = MAX (width, height); + gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h); + icon_size = MAX (w, h); context = gtk_spin_button_panel_get_context (spin_button, panel); state = gtk_spin_button_panel_get_state (spin_button, panel); @@ -833,8 +875,13 @@ gtk_spin_button_panel_get_width (GtkSpinButton *spin_button, g_object_unref (context); - return icon_size + button_padding.left + button_padding.right + - button_border.left + button_border.right; + if (width) + *width = icon_size + button_padding.left + button_padding.right + + button_border.left + button_border.right; + + if (height) + *height = icon_size + button_padding.top + button_padding.bottom + + button_border.top + button_border.bottom; } static void @@ -847,40 +894,58 @@ gtk_spin_button_panel_get_allocations (GtkSpinButton *spin_button, GtkAllocation spin_allocation, down_allocation, up_allocation, allocation; GtkRequisition requisition; gint req_height; - gint up_panel_width, down_panel_width; + gint down_panel_width, down_panel_height; + gint up_panel_width, up_panel_height; GtkStyleContext *context; - GtkBorder space; + GtkBorder border; gtk_widget_get_allocation (widget, &spin_allocation); gtk_widget_get_preferred_size (widget, &requisition, NULL); context = gtk_widget_get_style_context (GTK_WIDGET (spin_button)); - gtk_style_context_get_border (context, GTK_STATE_FLAG_NORMAL, &space); + gtk_style_context_get_border (context, GTK_STATE_FLAG_NORMAL, &border); - req_height = requisition.height - gtk_widget_get_margin_top (widget) - gtk_widget_get_margin_bottom (widget); - down_panel_width = gtk_spin_button_panel_get_width (spin_button, priv->down_panel); - up_panel_width = gtk_spin_button_panel_get_width (spin_button, priv->up_panel); + gtk_spin_button_panel_get_size (spin_button, priv->down_panel, &down_panel_width, &down_panel_height); + gtk_spin_button_panel_get_size (spin_button, priv->up_panel, &up_panel_width, &up_panel_height); - /* both panels have the same size, and they're as big as the entry allocation, - * excluding margins - */ - allocation.height = MIN (req_height, spin_allocation.height) - space.top - space.bottom; - allocation.y = spin_allocation.y + space.top + (spin_allocation.height - req_height) / 2; - down_allocation = up_allocation = allocation; + if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) + { + req_height = requisition.height - gtk_widget_get_margin_top (widget) - gtk_widget_get_margin_bottom (widget); - down_allocation.width = down_panel_width; - up_allocation.width = up_panel_width; + /* both panels have the same size, and they're as tall as the entry allocation, + * excluding margins + */ + allocation.height = MIN (req_height, spin_allocation.height) - border.top - border.bottom; + allocation.y = spin_allocation.y + border.top + (spin_allocation.height - req_height) / 2; + down_allocation = up_allocation = allocation; - /* invert x axis allocation for RTL */ - if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) - { - up_allocation.x = spin_allocation.x + space.left; - down_allocation.x = up_allocation.x + up_panel_width; + down_allocation.width = down_panel_width; + up_allocation.width = up_panel_width; + + /* invert x axis allocation for RTL */ + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) + { + up_allocation.x = spin_allocation.x + border.left; + down_allocation.x = up_allocation.x + up_panel_width; + } + else + { + up_allocation.x = spin_allocation.x + spin_allocation.width - up_panel_width - border.right; + down_allocation.x = up_allocation.x - down_panel_width; + } } else { - up_allocation.x = spin_allocation.x + spin_allocation.width - up_panel_width - space.right; - down_allocation.x = up_allocation.x - down_panel_width; + /* both panels have the same size, and they're as wide as the entry allocation */ + allocation.width = spin_allocation.width; + allocation.x = spin_allocation.x; + down_allocation = up_allocation = allocation; + + down_allocation.height = down_panel_height; + up_allocation.height = up_panel_height; + + up_allocation.y = spin_allocation.y; + down_allocation.y = spin_allocation.y + spin_allocation.height - down_allocation.height; } if (down_allocation_out) @@ -1018,6 +1083,31 @@ gtk_spin_button_unrealize (GtkWidget *widget) } } +static void +gtk_spin_button_set_orientation (GtkSpinButton *spin, + GtkOrientation orientation) +{ + GtkEntry *entry = GTK_ENTRY (spin); + GtkSpinButtonPrivate *priv = spin->priv; + + if (priv->orientation == orientation) + return; + + priv->orientation = orientation; + _gtk_orientable_set_style_classes (GTK_ORIENTABLE (spin)); + + /* change alignment if it's the default */ + if (priv->orientation == GTK_ORIENTATION_VERTICAL && + gtk_entry_get_alignment (entry) == 0.0) + gtk_entry_set_alignment (entry, 0.5); + else if (priv->orientation == GTK_ORIENTATION_HORIZONTAL && + gtk_entry_get_alignment (entry) == 0.5) + gtk_entry_set_alignment (entry, 0.0); + + g_object_notify (G_OBJECT (spin), "orientation"); + gtk_widget_queue_resize (GTK_WIDGET (spin)); +} + static int compute_double_length (double val, int digits) { @@ -1050,11 +1140,8 @@ gtk_spin_button_get_preferred_width (GtkWidget *widget, GtkSpinButtonPrivate *priv = spin_button->priv; GtkEntry *entry = GTK_ENTRY (widget); GtkStyleContext *style_context; - gint up_panel_width, down_panel_width; style_context = gtk_widget_get_style_context (widget); - up_panel_width = gtk_spin_button_panel_get_width (spin_button, priv->up_panel); - down_panel_width = gtk_spin_button_panel_get_width (spin_button, priv->down_panel); GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->get_preferred_width (widget, minimum, natural); @@ -1108,8 +1195,40 @@ gtk_spin_button_get_preferred_width (GtkWidget *widget, *natural = width; } - *minimum += up_panel_width + down_panel_width; - *natural += up_panel_width + down_panel_width; + if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) + { + gint down_panel_width; + gint up_panel_width; + + gtk_spin_button_panel_get_size (spin_button, priv->down_panel, &down_panel_width, NULL); + gtk_spin_button_panel_get_size (spin_button, priv->up_panel, &up_panel_width, NULL); + + *minimum += up_panel_width + down_panel_width; + *natural += up_panel_width + down_panel_width; + } +} + +static void +gtk_spin_button_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural) +{ + GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget); + GtkSpinButtonPrivate *priv = spin_button->priv; + + GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->get_preferred_height (widget, minimum, natural); + + if (priv->orientation == GTK_ORIENTATION_VERTICAL) + { + gint down_panel_height; + gint up_panel_height; + + gtk_spin_button_panel_get_size (spin_button, priv->down_panel, NULL, &down_panel_height); + gtk_spin_button_panel_get_size (spin_button, priv->up_panel, NULL, &up_panel_height); + + *minimum += up_panel_height + down_panel_height; + *natural += up_panel_height + down_panel_height; + } } static void @@ -1614,6 +1733,32 @@ gtk_spin_button_activate (GtkEntry *entry) GTK_ENTRY_CLASS (gtk_spin_button_parent_class)->activate (entry); } +static void +gtk_spin_button_get_frame_size (GtkEntry *entry, + gint *x, + gint *y, + gint *width, + gint *height) +{ + GtkSpinButtonPrivate *priv = GTK_SPIN_BUTTON (entry)->priv; + gint up_panel_width, up_panel_height; + gint down_panel_width, down_panel_height; + + gtk_spin_button_panel_get_size (GTK_SPIN_BUTTON (entry), priv->up_panel, &up_panel_width, &up_panel_height); + gtk_spin_button_panel_get_size (GTK_SPIN_BUTTON (entry), priv->down_panel, &down_panel_width, &down_panel_height); + + GTK_ENTRY_CLASS (gtk_spin_button_parent_class)->get_frame_size (entry, x, y, width, height); + + if (priv->orientation == GTK_ORIENTATION_VERTICAL) + { + if (y) + *y += up_panel_height; + + if (height) + *height -= up_panel_height + down_panel_height; + } +} + static void gtk_spin_button_get_text_area_size (GtkEntry *entry, gint *x, @@ -1622,21 +1767,33 @@ gtk_spin_button_get_text_area_size (GtkEntry *entry, gint *height) { GtkSpinButtonPrivate *priv = GTK_SPIN_BUTTON (entry)->priv; - gint up_panel_width, down_panel_width; + gint up_panel_width, up_panel_height; + gint down_panel_width, down_panel_height; - up_panel_width = gtk_spin_button_panel_get_width (GTK_SPIN_BUTTON (entry), priv->up_panel); - down_panel_width = gtk_spin_button_panel_get_width (GTK_SPIN_BUTTON (entry), priv->down_panel); + gtk_spin_button_panel_get_size (GTK_SPIN_BUTTON (entry), priv->up_panel, &up_panel_width, &up_panel_height); + gtk_spin_button_panel_get_size (GTK_SPIN_BUTTON (entry), priv->down_panel, &down_panel_width, &down_panel_height); GTK_ENTRY_CLASS (gtk_spin_button_parent_class)->get_text_area_size (entry, x, y, width, height); - if (gtk_widget_get_direction (GTK_WIDGET (entry)) == GTK_TEXT_DIR_RTL) + if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) { - if (x) - *x += up_panel_width + down_panel_width; + if (gtk_widget_get_direction (GTK_WIDGET (entry)) == GTK_TEXT_DIR_RTL) + { + if (x) + *x += up_panel_width + down_panel_width; + } + + if (width) + *width -= up_panel_width + down_panel_width; } + else + { + if (y) + *y += up_panel_height; - if (width) - *width -= up_panel_width + down_panel_width; + if (height) + *height -= up_panel_height + down_panel_height; + } } static void diff --git a/tests/testspinbutton.c b/tests/testspinbutton.c index 01dfb5d516..9f8ada41fb 100644 --- a/tests/testspinbutton.c +++ b/tests/testspinbutton.c @@ -18,43 +18,62 @@ #include "config.h" #include -int -main (int argc, char **argv) +static gint num_windows = 0; + +static gboolean +on_delete_event (GtkWidget *w, + GdkEvent *event, + gpointer user_data) { - GtkWidget *window, *mainbox; - int max; + num_windows--; + if (num_windows == 0) + gtk_main_quit (); + + return FALSE; +} - gtk_init (&argc, &argv); +static void +prepare_window_for_orientation (GtkOrientation orientation) +{ + GtkWidget *window, *mainbox; + int max; - window = gtk_window_new (GTK_WINDOW_TOPLEVEL); - g_signal_connect (window, "delete_event", gtk_main_quit, NULL); + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + g_signal_connect (window, "delete_event", G_CALLBACK (on_delete_event), NULL); - mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); - gtk_container_add (GTK_CONTAINER (window), mainbox); + mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + gtk_container_add (GTK_CONTAINER (window), mainbox); - for (max = 9; max <= 999999999; max = max * 10 + 9) { - GtkAdjustment *adj = gtk_adjustment_new (max, - 1, max, - 1, - (max + 1) / 10, - 0.0); + for (max = 9; max <= 999999999; max = max * 10 + 9) + { + GtkAdjustment *adj = gtk_adjustment_new (max, + 1, max, + 1, + (max + 1) / 10, + 0.0); - GtkWidget *spin = gtk_spin_button_new (adj, 1.0, 0); - GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + GtkWidget *spin = gtk_spin_button_new (adj, 1.0, 0); + gtk_orientable_set_orientation (GTK_ORIENTABLE (spin), orientation); + gtk_widget_set_halign (GTK_WIDGET (spin), GTK_ALIGN_CENTER); - gtk_box_pack_start (GTK_BOX (hbox), - spin, - FALSE, - FALSE, - 2); + GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + gtk_box_pack_start (GTK_BOX (hbox), spin, FALSE, FALSE, 2); + gtk_container_add (GTK_CONTAINER (mainbox), hbox); + } - gtk_container_add (GTK_CONTAINER (mainbox), hbox); + gtk_widget_show_all (window); + num_windows++; +} - } +int +main (int argc, char **argv) +{ + gtk_init (&argc, &argv); - gtk_widget_show_all (window); + prepare_window_for_orientation (GTK_ORIENTATION_HORIZONTAL); + prepare_window_for_orientation (GTK_ORIENTATION_VERTICAL); - gtk_main (); + gtk_main (); - return 0; + return 0; } -- 2.30.2